import json
import re
import os
import shutil
import inspect
import pymysql
import pandas as pd

from zhipuai import ZhipuAI

api_key = "4956db3da95d43eab77efa6937882679.Xm27NhBWZPJE3ORb"
client = ZhipuAI(api_key=api_key)

# messages = [{"role":"user","content":"请问什么是推理链?"}]
# response = client.chat.completions.create(model="glm-4",
#                                           messages=messages)
# print(response.choices[0].message.content)
#
# with open(r"F:\ai\03大模型开发实战\08 低代码智能开发平台案例实践\tested functions\%s\%s_prompt.json" % ('get_email_count', 'get_email_count'), "r", encoding="utf8") as f:
#     msg = json.load(f)
#
# chain_of_prompt = "以下是个一个成功运行的推理链条，推理分为三个阶段，各阶段推理内容如下：%s。" % msg
# response = client.chat.completions.create(
#                         model="glm-4",
#                         messages=[{"role": "user",  "content": "以下是一个推理链，用于创建一个满足某个功能的函数，推理链如下：%s。请帮我介绍下这个推理链" % chain_of_prompt}]
# )
# print(response.choices[0].message.content)

def prompt_modified(function_name,system_content=r"F:\ai\03大模型开发实战\08 低代码智能开发平台案例实践\资料\复杂需求推理链\复杂需求推理链.md",model="glm-4",g=globals()):
    """
        邮箱项目的外部函数审查函数，用于审查外部函数创建流程提示是否正确以及最终创建的代码是否正确
        :param function_name: 必要参数，字符串类型，表示审查对象名称；
        :param system_content: 可选参数，默认取值为字符串推理链修改.md，表示此时审查函数外部挂载文档名称，需要是markdwon格式文档；
        :param model: 可选参数，表示调用的Chat模型，默认选glm-4；
        :param g: 可选参数，表示extract_function_code函数作用域，默认为globals()，即在当前操作空间全域内生效；
        :return：审查结束后新创建的函数名称
    """
    print("正在执行审查函数，审查对象:%s" % function_name)
    with open(r"F:\ai\03大模型开发实战\08 低代码智能开发平台案例实践\资料\my_mail数据字典.md","r",encoding="utf8") as f:
        data_content = f.read()

    with open(system_content,"r",encoding="utf8") as f:
        md_content = f.read()

    # 读取原函数全部提示内容
    with open(r"F:\ai\03大模型开发实战\08 低代码智能开发平台案例实践\tested functions\%s\%s_prompt.json" %(function_name,function_name),"r",encoding="utf8") as f:
        msg = json.load(f)

    # 将其保存为字符串
    msg_str = json.dumps(msg)
    print(msg)

    # 进行审查
    response = client.chat.completions.create(
        model=model,
        messages=[{"role":"system","content":data_content},
                  {"role":"system","content":md_content},
                  {"role":"user","content":"以下是一个错误的邮箱项目的推理链，请你按照要求对其进行修改：%s" % msg_str}]
    )

    modified_result = response.choices[0].message.content
    print(modified_result)


    print("-----------------------------------------------------")

    def extract_json(s):
        pattern = r'```[jJ][sS][oO][nN]\s*({.*?})\s*```'
        match = re.search(pattern, s, re.DOTALL)
        if match:
            return match.group(1)
        else:
            return s

    modified_json = extract_json(modified_result)
    print("去掉json说明后的数据:\n%s" % modified_json)

    print("********************************************")

    # 提取函数源码
    code = json.loads(modified_json)["stage2"][1]["content"]
    print("提取函数源码:\n %s" % code)

    print("--------************")

    code = extract_code(code)
    print("截取后的函数:\n %s" % code)

    # 提取函数名
    match = re.search(r"def (\w+)",code)
    function_new_name = match.group(1)

    print("审查结束，新的函数名称为：%s。\n正在运行该函数定义过程，并保存函数源码与prompt" % function_new_name)
    exec(code,g)

    # 在untested文件夹内创建函数同名文件夹
    directory = r"F:\ai\03大模型开发实战\08 低代码智能开发平台案例实践\untested functions\%s" % function_new_name
    if not os.path.exists(directory):
        os.makedirs(directory)

    # 写入函数
    with open(r"F:\ai\03大模型开发实战\08 低代码智能开发平台案例实践\untested functions\%s\%s.py" %(function_new_name,function_new_name),"w",encoding="utf8") as f:
        f.write(code)

    # 写入提示
    with open(r"F:\ai\03大模型开发实战\08 低代码智能开发平台案例实践\untested functions\%s\%s_prompt.json" %(function_new_name,function_new_name),"w",encoding="utf8") as f:
        json.dump(json.loads(modified_json),f)

    print(r'新函数提示示例保存在F:\ai\03大模型开发实战\08 低代码智能开发平台案例实践\untested functions/%s/%s_prompt.json文件中' % (function_new_name, function_new_name))
    print("%s函数已在当前操作空间定义，可以进行效果测试" % function_new_name)

    return function_new_name

# prompt_modified(function_name="get_email_count")


def extract_code(s):
    """
    函数提取函数，同时执行函数内容，可以选择打印函数信息，并选择代码保存的地址
    如果输入的字符串s是一个包含Python代码的Markdown格式字符串，提取出代码部分。
    否则，返回原字符串。

    参数:
    s: 输入的字符串。

    返回:
    提取出的代码部分，或原字符串。
    """
    # 判断字符串是否是Markdown格式
    if "```python" in s or "Python" in s or "PYTHON" in s:
        # 找到代码块的开始和结束位置
        if "import" in s:
            start = s.find("import")
        else:
            start = s.find("def")
        if ("```\n") in s:
            end = s.find("```", start)# 提取代码部分
            code = s[start:end]
        else:
            # 提取代码部分
            code = s[start:]
    else:
        code = s
    return code

def extract_function_code(s,detail=0,tested=False,g=globals()):


    # 提取代码字符串
    code=extract_code(s)

    # 提取函数名称
    function_name = re.search(r"def (\w+)",code).group(1)

    # 在untested文件夹内创建函数同名文件夹
    directory = r"F:\ai\03大模型开发实战\08 低代码智能开发平台案例实践\untested functions\%s" % function_name
    if not os.path.exists(directory):
        os.makedirs(directory)

    # 将函数写入本地
    if tested == False:
        with open(r"F:\ai\03大模型开发实战\08 低代码智能开发平台案例实践\untested functions\%s\%.py" %(function_name,function_name),"w",encoding="utf8") as f:
            f.write(code)
    else:
        # 调用remove_to_test函数将函数文件夹转移至tested文件夹内
        remove_to_tested(function_name)
        with open(r"F:\ai\03大模型开发实战\08 低代码智能开发平台案例实践\tested functions\%s\%.py" %(function_name,function_name),"w",encoding="utf8") as f:
            f.write(code)

    # 执行该函数
    try:
        exec(code,g)
    except Exception as e:
        print("An error occurred while executing the code:")
        print(e)

    # 打印函数名称
    if detail == 0:
        print("函数名称是:%s" % function_name)

    if detail == 1:
        if tested == False:
            with open(r"F:\ai\03大模型开发实战\08 低代码智能开发平台案例实践\untested functions\%s\%.py" % (function_name, function_name), "r", encoding="utf8") as f:
                content = f.read()
        else:
            with open(r"F:\ai\03大模型开发实战\08 低代码智能开发平台案例实践\tested functions\%s\%.py" % (function_name, function_name), "r", encoding="utf8") as f:
                content = f.read()
        print(content)

    return function_name

def show_functions(tested=False,if_print=False):
    """
    打印tested或untested文件夹内全部函数
    """
    current_directory = r"F:\ai\03大模型开发实战\08 低代码智能开发平台案例实践"
    if tested == False:
        directory = current_directory + r'\functions\untested functions'
    else:
        directory = current_directory + r'\functions\tested functions'
    files_and_directories = os.listdir(directory)
    # 过滤结果，只保留.py文件和非__pycache__文件夹
    files_and_directories = files_and_directories = [name for name in files_and_directories if (
                os.path.splitext(name)[1] == '.py' or os.path.isdir(
            os.path.join(directory, name))) and name != ".ipynb_checkpoints"]

    if if_print != False:
        for name in files_and_directories:
            print(name)

    return files_and_directories

def code_generate(req,few_shot="all",model="glm-4",g=globals(),detail=0):
    """
        Function calling外部函数自动创建函数，可以根据用户的需求，直接将其翻译为Chat模型可以直接调用的外部函数代码。
        :param req: 必要参数，字符串类型，表示输入的用户需求；
        :param few_shot: 可选参数，默认取值为字符串all，用于描述Few-shot提示示例的选取方案，当输入字符串all时，则代表提取当前外部函数库中全部测试过的函数作为Few-shot；\
        而如果输入的是一个包含了多个函数名称的list，则表示使用这些函数作为Few-shot。
        :param model: 可选参数，表示调用的Chat模型，默认选取glm-4；
        :param g: 可选参数，表示extract_function_code函数作用域，默认为globals()，即在当前操作空间全域内生效；
        :param detail: 可选参数，默认取值为0，还可以取值为1，表示extract_function_code函数打印新创建的外部函数细节；
        :return：新创建的函数名称。需要注意的是，在函数创建时，该函数也会在当前操作空间被定义，后续可以直接调用；
    """
    # 提取提示示例的函数名称
    if few_shot == "all":
        few_shot_functions_name = show_functions(tested=True)
    elif type(few_shot) == list:
        few_shot_functions_name = few_shot

    # 读取各阶段系统提示
    with open(r"F:\ai\03大模型开发实战\08 低代码智能开发平台案例实践\tested functions\%s.json" % 'system_messages', "r",encoding="utf8") as f:
        system_messages = json.load(f)

    # 各阶段提示message对象
    few_shot_messages_CM = []
    few_shot_messages_CD = []
    few_shot_messages = []

    # 先保存第一条消息，也就是system message
    few_shot_messages_CD += system_messages["system_message_CD"]
    few_shot_messages_CM += system_messages["system_message_CM"]
    few_shot_messages += system_messages["system_message"]

    # 创建不同阶段提示message
    for function_name in few_shot_functions_name:
        with open(r"F:\ai\03大模型开发实战\08 低代码智能开发平台案例实践\tested functions\%s\%s_prompt.json" % (function_name,function_name),"r", encoding="utf8") as f:
            msg = json.load(f)
        few_shot_messages_CD += msg["stage1_CD"]
        few_shot_messages_CM += msg["stage1_CM"]
        few_shot_messages += msg["stage2"]

    # 读取用户需求，作为第一阶段CD环节User content
    new_req_CD_input = req
    few_shot_messages_CD.append({"role":"user","content":new_req_CD_input})

    print('第一阶段CD环节提示创建完毕，正在进行CD提示...')

    # 第一阶段CD环节Chat模型调用过程
    response = client.chat.completions.create(model=model,
                                              messages=few_shot_messages_CD)
    new_req_pi = response.choices[0].message.content

    print("第一阶段CD环节返回:%s" % new_req_pi)

    print('第一阶段CD环节提示完毕')

    # 第一阶段CM环节Messages创建
    new_req_CM_input = new_req_CD_input+new_req_pi
    few_shot_messages_CM.append({"role":"user","content":new_req_CM_input})

    print('第一阶段CM环节提示创建完毕，正在进行第一阶段CM提示...')

    # 第一阶段CM环节Chat模型调用过程
    response = client.chat.completions.create(model=model,
                                              messages=few_shot_messages_CM)
    new_req_description = response.choices[0].message.content
    print("第一阶段CM环节:%s" % new_req_description)

    print('第一阶段CM环节提示完毕')

    # 第二阶段Messages创建过程
    few_shot_messages.append({"role":"user","content":new_req_description})

    print('第二阶段提示创建完毕，正在进行第二阶段提示...')

    # 第二阶段Chat模型调用过程
    response = client.chat.completions.create(model=model,
                                              messages=few_shot_messages)
    new_req_function = response.choices[0].message.content

    print("第二阶段提示:%s" % new_req_function)

    print('第二阶段提示完毕，准备运行函数并编写提示示例')

    # 提取函数并运行，创建函数名称对象，统一都写入untested文件夹内
    function_name = extract_function_code(s=new_req_function,detail=detail,g=g)
    print(r'新函数保存在F:\ai\03大模型开发实战\08 低代码智能开发平台案例实践\untested functions\%s\%s.py文件中' % (function_name, function_name))

    # 创建该函数提示示例
    new_req_messages_CD= [{"role":"user","content":new_req_CD_input},
                          {"role":"assistant","content":new_req_pi}]

    new_req_messages_CM = [{"role":"user","content":new_req_CM_input},
                           {"role":"assistant","content":new_req_description}]

    with open(r"F:\ai\03大模型开发实战\08 低代码智能开发平台案例实践\untested functions\%s\%s.py" %(function_name,function_name),"r",encoding="utf8") as f:
        new_req_function = f.read()

    new_req_messages = [{"role":"user","content":new_req_description},
                        {"role":"assistant","content":new_req_function}]

    new_req_prompt = {
        "stage1_CD":new_req_messages_CD,
        "stage1_CM":new_req_messages_CM,
        "stage2":new_req_messages
    }

    with open(r"F:\ai\03大模型开发实战\08 低代码智能开发平台案例实践\untested functions\%s\%s_prompt.json" % (function_name, function_name), "w", encoding="utf8") as f:
        json.dump(new_req_prompt,f)

    print(r'新函数提示示例保存在F:\ai\03大模型开发实战\08 低代码智能开发平台案例实践\untested functions\%s\%s_prompt.json文件中' % (function_name, function_name))
    print('done')
    return function_name

def remove_to_tested(function_name):
    """
    将函数同名文件夹由untested文件夹转移至tested文件夹内。\
    完成转移则说明函数通过测试，可以使用。
    """
    # with open(r"F:\ai\03大模型开发实战\08 低代码智能开发平台案例实践\untested functions\%s\%.py" %(function_name,function_name),"r",encoding="utf8") as f:
    #     function_code = f.read()

    src_dir = r"F:\ai\03大模型开发实战\08 低代码智能开发平台案例实践\untested functions\%s" % function_name
    dest_dir = r"F:\ai\03大模型开发实战\08 低代码智能开发平台案例实践\tested functions\%s" % function_name

    shutil.move(src_dir,dest_dir)

def auto_functions(function_list):
    """
    Chat模型的functions参数编写函数
    :param functions_list: 包含一个或者多个函数对象的列表；
    :return：满足Chat模型functions参数要求的functions对象
    """
    def functions_generate(function_list):
        # 创建空列表，用于保存每个函数的描述字典
        functions = []
        # 对每个外部函数进行循环
        for function in function_list:
            # 读取函数对象的函数说明
            function_description = inspect.getdoc(function)
            # 读取函数的函数名字符串
            function_name = function.__name__
            ## 提示词 one-shot
            system_prompt1 = """输出结果必须是一个JSON格式的字典,举个例子：
                        [{'type': 'function', 'function': {'name': 'sunwukong_function', 'description': '该函数定义了数据集计算过程，接收一个数据表字符串参数，并返回一个JSON格式的Dataframe类型对象。', 'parameters': {'type': 'object', 'properties': {'data': {'type': 'string', 'description': '带入计算的数据表，用字符串进行表示'}}, 'required': ['data'], 'additionalProperties': False}}}]
                        """
            system_prompt2 = "以下是某个函数的说明:%s,输出格式必须是一个JSON格式的字典，只输出这个字典即可，前后不需要任何前后修饰或说明语句" % function_description

            user_prompt = '根据这个函数的函数说明，请帮我创建一个JSON格式的字典，这个字典有如下5点要求：\
                                       1.字典总共有三个键值对；\
                                       2.第一个键值对的Key是字符串name，value是该函数的名字：%s，也是字符串；\
                                       3.第二个键值对的Key是字符串description，value是该函数的函数的功能说明，也是字符串；\
                                       4.第三个键值对的Key是字符串parameters，value是一个JSON Schema对象，用于说明该函数的参数输入规范。\
                                       5.输出结果必须是一个JSON格式的字典，只输出这个字典即可，前后不需要任何前后修饰或说明的语句' % function_name

            response = client.chat.completions.create(model="glm-4",
                                                      messages=[{"role":"system","content":system_prompt1},
                                                                {"role":"system","content":system_prompt2},
                                                                {"role":"user","content":user_prompt}])
            json_str = response.choices[0].message.content.replace("```json","").replace("```","")
            json_function_description = json.loads(json_str)
            json_str = {"type":"function","function":json_function_description}
            functions.append(json_str)
        return functions

    ## 最大可以尝试4次
    max_attempts = 4
    attempts = 0

    while attempts < max_attempts:
        try:
            functions = functions_generate(function_list)
            # 如果代码成功执行，跳出循环
            break
        except Exception as e:
            # 增加尝试次数
            attempts +=1
            print("发生错误：", e)
            if attempts == max_attempts:
                print("已达到最大尝试次数，程序终止。")
                raise  # 重新引发最后一个异常
            else:
                print("正在重新运行...")
    return functions


def run_conversation(messages,function_list=None,model="glm-4"):
    """
        能够自动执行外部函数调用的对话模型
        :param messages: 必要参数，字典类型，输入到Chat模型的messages参数对象
        :param functions_list: 可选参数，默认为None，可以设置为包含全部外部函数的列表对象
        :param model: Chat模型，可选参数，默认模型为glm-4
        :return：Chat模型输出结果
    """
    # 如果没有外部函数库，则执行普通的对话任务
    if function_list == None:
        response = client.chat.completions.create(model=model,messages=messages)
        response_message = response.choices[0].message
        final_response = response_message.content
    # 若存在外部函数库，则需要灵活选取外部函数并进行回答
    else:
        # 创建functions对象
        tools = auto_functions(function_list)

        # 创建外部函数库字典
        avaiable_functions = {func.__name__ for func in function_list}
        print("可用的外部函数名称:%s" % avaiable_functions)

        # 第一次调用大模型
        response = client.chat.completions.create(model=model,
                                                  messages=messages,
                                                  tools=tools,
                                                  tool_choice="auto")

        response_message = response.choices[0].message

        tool_calls =  response_message.tool_calls
        if tool_calls:
            ## GLM-4 Function Call的使用方式
            messages.append(response.choices[0].message.model_dump())
            for tool_call in tool_calls:
                function_name = tool_call.function.name
                function_tool_call = avaiable_functions[function_name]
                function_args = json.loads(tool_call.function.arguments)
                ## 真正执行外部函数的就是这儿的代码
                function_response = function_tool_call(**function_args)
                messages.append({"role":"tool",
                                 "content":function_response,
                                 "function_tool_call":tool_call.id})
            ## 第二次调用模型
            second_response = client.chat.completions.create(model=model,messages=messages,tools=tools)
            # 获取最终结果
            print("获取最终结果:%s" % second_response.choices[0].message)
            final_response = second_response.choices[0].message.content
        else:
            final_response = response_message.content

    return final_response


def function_test(function_name,req,few_shot,model="glm-4",g=globals()):
    with open(r"F:\ai\03大模型开发实战\08 低代码智能开发平台案例实践\资料\my_mail数据字典.md","r",encoding="utf8") as f:
        data_content = f.read()
    def test_messages(user_content):
        messages = [{"role":"system","content":data_content},
                    {"role":"system","content":"我的邮箱号叫me"},
                    {"role":"user","content":user_content}]
        return messages

    messages = test_messages(data_content)
    new_function = globals()[function_name]
    function_list = [new_function]

    print("根据既定用户需求req进行%s函数功能测试，请确保当该函数已经在当前操作空间定义..." % function_name)

    # 有可能在run_conversation环节报错
    # 若没报错，则运行：
    try:
        ## 直接调用看当前函数给出来的结果是否正确
        ## 有两种可能：1，代码能运行 2. 代码不能运行
        final_response = run_conversation(messages=messages,function_list=function_list,model=model)
        print("当前函数运行结果：'%s'" % final_response)
        ## 如果代码能运行看一下是否能满足需求
        feedback=input("函数功能是否满足要求(yes/no)?")
        if feedback.lower() == "yes":
            print("函数功能通过测试，正在将函数写入tested文件夹")
            ## 如果满足就通过测试
            remove_to_tested(function_name)
            print("done")
        else:
            ## 如果不满足需求
            next_step = input("函数功能未通过测试，是1.需要再次进行测试，还是2.进入debug流程？")
            if next_step == "1":
                print("准备再次测试...")
                ## 再次运行
                function_test(function_name,req,few_shot,model)
            else:
                ## 进行Debug，选择方案
                solution = input("请选择debug方案：\n1.再次执行函数创建流程，并测试结果；\n2.执行审查函数\
                \n3.重新输入用户需求；\n4.退出程序，进行手动尝试")
                if solution == "1":
                    # 再次运行函数创建过程
                    print("好的，正在尝试再次创建函数，请稍等...")
                    few_shot_str = input("准备再次测试，请问是1.采用此前Few-shot方案，还是2.带入全部函数示例进行Few-shot？")
                    if few_shot_str == "1":
                        function_name = code_generate(req,few_shot,model,g)
                    else:
                        function_name = code_generate(req=re,few_shot="all",model=model,g=g)
                    ## 构建完了以后继续运行
                    function_test(function_name,req,few_shot, model, g)
                elif solution == "2":
                    # 执行审查函数
                    print("好的，执行审查函数，请稍等...")
                    prompt_modified(function_name=function_name, model="glm-4", g=g)
                    # 接下来带入进行测试
                    print("新函数已创建，接下来带入进行测试...")
                    function_test(function_name, req, few_shot, model, g)
                elif solution == "3":
                    ## 用户重新输入需求，也就意味着重新
                    new_req = input("好的，请再次输入用户需求，请注意，用户需求描述方法将极大程度影响最终函数创建结果。")
                    few_shot_str = input("接下来如何运行代码创建函数？1.采用此前Few-shot方案；\n2.使用全部外部函数作为Few-shot")
                    if few_shot_str == "1":
                        function_name = code_generate(req=new_req,few_shot=few_shot,model=model,g=g)
                    else:
                        function_name = code_generate(req=new_req,few_shot="all",model=model,g=g)
                    function_test(function_name,new_req,few_shot, model, g)
                elif solution == '4':
                    print("加油~")
    # run_conversation报错时则运行：
    except Exception as e:
        next_step = input("run_conversation无法正常运行，接下来是1.再次运行运行run_conversation，还是2.进入debug流程？")
        if next_step == "1":
            function_test(function_name,req,few_shot, model, g)
        else:
            solution = input("请选择debug方案：\n1.再次执行函数创建流程，并测试结果；\n2.执行审查函数\
                        \n3.重新输入用户需求；\n4.退出程序，进行手动尝试")
            if solution == '1':
                # 再次运行函数创建过程
                print("好的，正在尝试再次创建函数，请稍等...")
                few_shot_str = input("准备再次测试，请问是1.采用此前Few-shot方案，还是2.带入全部函数示例进行Few-shot？")
                if few_shot_str == '1':
                    function_name = code_generate(req=req, few_shot=few_shot, model=model, g=g)
                else:
                    function_name = code_generate(req=req, few_shot='all', model=model, g=g)
                function_test(function_name=function_name, req=req, few_shot=few_shot, g=g)
            elif solution == '2':
                # 执行审查函数
                print("好的，执行审查函数，请稍等...")
                max_attempts = 3
                attempts = 0

                while attempts < max_attempts:
                    try:
                        function_name = prompt_modified(function_name=function_name, model="glm-4",g=g)
                        break  # 如果代码成功执行，跳出循环
                    except Exception as e:
                        attempts += 1  # 增加尝试次数
                        print("发生错误：", e)
                        if attempts == max_attempts:
                            print("已达到最大尝试次数，程序终止。")
                            raise  # 重新引发最后一个异常
                        else:
                            print("正在重新运行审查程序...")
                # 接下来带入进行测试
                print("新函数已创建，接下来带入进行测试...")
                function_test(function_name=function_name, req=req, few_shot=few_shot, g=g)
            elif solution == '3':
                new_req = input("好的，请再次输入用户需求，请注意，用户需求描述方法将极大程度影响最终函数创建结果。")
                few_shot_str = input(
                    "接下来如何运行代码创建函数？1.采用此前Few-shot方案；\n2.使用全部外部函数作为Few-shot")
                if few_shot_str == '1':
                    function_name = code_generate(req=new_req, few_shot=few_shot, model=model, g=g)
                else:
                    function_name = code_generate(req=new_req, few_shot='all', model=model, g=g)
                function_test(function_name=function_name, req=new_req, few_shot=few_shot, g=g)
            elif solution == '4':
                print("加油~")


def get_latest_email(userid):
    """
        获取最新的一封邮件
        参数:
        user_id: 要检索邮件的用户的ID。默认值是'me'，数据格式为字符串类型。

        返回:
        一个列表，其中每个元素都是一个字典，表示一封邮件。每个字典包含以下键：
        'from_userid': 发件人ID。
        'date': 邮件的发送日期。
        'subject': 邮件的主题。
        'snippet': 邮件的摘要（前100个字符）。
    """
    mysql_pw = "1qaz2wsx"

    connection = pymysql.connect(
        host="localhost",
        user="root",
        passwd=mysql_pw,
        db="my_mail",
        charset="utf8"
    )

    sql_query = f"SELECT * FROM mailbox WHERE userid = '{me}' ORDER BY date DESC LIMIT 1"

    try:
        with connection.cursor() as cursor:
            cursor.execute(sql_query)
            results = cursor.fetchall()
    finally:
        cursor.close()

    column_names = [desc[0] for desc in cursor.description]
    # 使用results和column_names创建DataFrame
    df = pd.DataFrame(results,column_names)

    return df.to_json(orient="records")


function_test(function_name = 'get_latest_email',
              req = '请帮我查下mailbox邮箱里最新一封邮件内容。',
              few_shot = 'all')


